{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.364606\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 4.448814 analytic: 4.448814, relative error: 1.131721e-08\n",
      "numerical: 0.803491 analytic: 0.803491, relative error: 6.591547e-09\n",
      "numerical: -4.316572 analytic: -4.316572, relative error: 8.879102e-10\n",
      "numerical: 1.399013 analytic: 1.399013, relative error: 8.700786e-08\n",
      "numerical: -0.739269 analytic: -0.739269, relative error: 7.995936e-08\n",
      "numerical: 2.110418 analytic: 2.110418, relative error: 1.765572e-08\n",
      "numerical: -1.249506 analytic: -1.249506, relative error: 2.340411e-09\n",
      "numerical: 2.042361 analytic: 2.042361, relative error: 2.976949e-08\n",
      "numerical: 2.041832 analytic: 2.041832, relative error: 2.027293e-08\n",
      "numerical: -0.408771 analytic: -0.408771, relative error: 8.367203e-08\n",
      "numerical: 2.042933 analytic: 2.042933, relative error: 4.109457e-09\n",
      "numerical: -1.388908 analytic: -1.388908, relative error: 2.302196e-08\n",
      "numerical: -0.517299 analytic: -0.517299, relative error: 1.561286e-07\n",
      "numerical: 1.221305 analytic: 1.221305, relative error: 3.993086e-08\n",
      "numerical: -0.162553 analytic: -0.162553, relative error: 2.739976e-07\n",
      "numerical: 1.476669 analytic: 1.476669, relative error: 4.964665e-09\n",
      "numerical: -1.262721 analytic: -1.262721, relative error: 7.249271e-10\n",
      "numerical: -0.969402 analytic: -0.969403, relative error: 7.854812e-08\n",
      "numerical: 2.014748 analytic: 2.014748, relative error: 5.415087e-08\n",
      "numerical: 0.401549 analytic: 0.401549, relative error: 6.033886e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.364606e+00 computed in 14.873844s\n",
      "vectorized loss: 2.364606e+00 computed in 0.001966s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.328531 val accuracy: 0.341000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.314327 val accuracy: 0.333000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.316898 val accuracy: 0.343000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.319388 val accuracy: 0.328000\n",
      "best validation accuracy achieved during cross-validation: 0.343000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for learning_rate in learning_rates:\n",
    "    for regularization_strength in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        loss_hist = softmax.train(X_train, y_train, learning_rate=learning_rate, \n",
    "                              reg=regularization_strength, num_iters=1500, verbose=False)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        training_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        validation_accuracy = np.mean(y_val == y_val_pred)\n",
    "        results[(learning_rate, regularization_strength)] = (training_accuracy, validation_accuracy)\n",
    "        if best_val < validation_accuracy:\n",
    "            best_val = validation_accuracy\n",
    "            best_softmax = softmax\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.327000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$True\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
